package com.xjscrm.console.service.customer.chat;

import cn.hutool.core.util.IdUtil;
import com.alibaba.fastjson.JSON;
import com.google.common.collect.Lists;
import com.xjscrm.common.annotation.MerId;
import com.xjscrm.common.enums.RedisCacheKeyEnum;
import com.xjscrm.common.exception.BusinessException;
import com.xjscrm.console.dto.ChatDispatchSettingsDTO;
import com.xjscrm.console.dto.chat.setting.*;
import com.xjscrm.console.entity.ChatDispatchSettings;
import com.xjscrm.console.mapper.ChatDispatchSettingsMapper;
import com.xjscrm.console.vo.LoginVO;
import com.xjscrm.console.vo.chat.ChatDispatchSettingsVO;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.Objects;

/**
 * @author mingyang.chen create in 2024/3/18 10:39
 */
@Service
public class ChatDispatchSettingsService {

    @Resource
    private ChatDispatchSettingsMapper chatDispatchSettingsMapper;

    @Autowired
    private RedisTemplate<Object, Object> redisTemplate;


    public int deleteByPrimaryKey(@MerId Long merId, Long id) {
        return chatDispatchSettingsMapper.deleteByPrimaryKey(id);
    }


    public int insertSelective(ChatDispatchSettings record) {
        return chatDispatchSettingsMapper.insertSelective(record);
    }


    public ChatDispatchSettings selectByPrimaryKey(@MerId Long merId, Long id) {
        return chatDispatchSettingsMapper.selectByPrimaryKey(id);
    }


    public int updateByPrimaryKeySelective(ChatDispatchSettings record) {
        return chatDispatchSettingsMapper.updateByPrimaryKeySelective(record);
    }

    public ChatDispatchSettingsVO get(LoginVO login) {
        return get(login.getMerId());
    }

    public ChatDispatchSettingsVO get(@MerId Long merId) {

//        String confCacheKey = String.format(RedisCacheKeyEnum.MER_CHAT_DISPATCH_CONF.getKey(), merId);
//        String confJson = (String) redisTemplate.opsForValue().get(confCacheKey);
//        if (StringUtils.isNotBlank(confJson)) {
//            ChatDispatchSettingsVO dispatchSettingsVO = JSON.parseObject(confJson, ChatDispatchSettingsVO.class);
//            if (Objects.nonNull(dispatchSettingsVO) && Objects.nonNull(dispatchSettingsVO.getId())) {
//                return dispatchSettingsVO;
//            }
//        }

        ChatDispatchSettings chatDispatchSettings = chatDispatchSettingsMapper.selectByMerId(merId);
        if (Objects.isNull(chatDispatchSettings)) {
            return this.init(merId);
        }
        ChatDispatchSettingsVO dispatchSettingsVO = new ChatDispatchSettingsVO();
        BeanUtils.copyProperties(chatDispatchSettings, dispatchSettingsVO);
        //
        if (StringUtils.isNotBlank(chatDispatchSettings.getSessionAccessConf())) {
            dispatchSettingsVO.setSessionAccessConf(JSON.parseObject(chatDispatchSettings.getSessionAccessConf(), ChatSessionAccessJsonDTO.class));
        }
        if (StringUtils.isNotBlank(chatDispatchSettings.getAllocateRuleConf())) {
            dispatchSettingsVO.setAllocateRuleConf(JSON.parseObject(chatDispatchSettings.getAllocateRuleConf(), ChatAllocateRuleJsonDTO.class));
        }
        if (StringUtils.isNotBlank(chatDispatchSettings.getDispatchConditionConf())) {
            dispatchSettingsVO.setDispatchConditionConf(JSON.parseObject(chatDispatchSettings.getDispatchConditionConf(), ChatDispatchConditionJsonDTO.class));
        }
        if (StringUtils.isNotBlank(chatDispatchSettings.getDialogRuleConf())) {
            dispatchSettingsVO.setDialogRuleConf(JSON.parseObject(chatDispatchSettings.getDialogRuleConf(), ChatDialogRuleJsonDTO.class));
        }
        if (StringUtils.isNotBlank(chatDispatchSettings.getAutoReplyConf())) {
            dispatchSettingsVO.setAutoReplyConf(JSON.parseObject(chatDispatchSettings.getAutoReplyConf(), ChatAutoReplyJsonDTO.class));
        }
        if (StringUtils.isNotBlank(chatDispatchSettings.getEvaluateConf())) {
            dispatchSettingsVO.setEvaluateConf(JSON.parseObject(chatDispatchSettings.getEvaluateConf(), ChatEvaluateJsonDTO.class));
        }
        if (StringUtils.isNotBlank(chatDispatchSettings.getOtherSettingConf())) {
            dispatchSettingsVO.setOtherSettingConf(JSON.parseObject(chatDispatchSettings.getOtherSettingConf(), ChatOtherSettingJsonDTO.class));
        }
        return dispatchSettingsVO;
    }

    public ChatDispatchSettingsVO init(@MerId Long merId) {

        ChatDispatchSettingsVO result = new ChatDispatchSettingsVO();
        ChatDispatchSettings chatDispatchSettings = new ChatDispatchSettings();

        ChatSessionAccessJsonDTO chatSessionAccessJsonDTO = new ChatSessionAccessJsonDTO();
        chatSessionAccessJsonDTO.setOpenOrder(0);
        chatDispatchSettings.setSessionAccessConf(JSON.toJSONString(chatSessionAccessJsonDTO));
        result.setSessionAccessConf(chatSessionAccessJsonDTO);

        chatDispatchSettings.setId(IdUtil.getSnowflakeNextId());
        chatDispatchSettings.setMerId(merId);
        chatDispatchSettings.setOpenDispatch(0);

        result.setId(chatDispatchSettings.getId());
        result.setMerId(merId);
        result.setOpenDispatch(0);

        // 分配规则
        ChatAllocateRuleJsonDTO chatAllocateRuleJson = new ChatAllocateRuleJsonDTO();
        chatAllocateRuleJson.setStaff(new ChatAllocateRuleJsonDTO.StaffAllocate(100));
        chatDispatchSettings.setAllocateRuleConf(JSON.toJSONString(chatAllocateRuleJson));
        result.setAllocateRuleConf(chatAllocateRuleJson);
        // 分发条件
        ChatDispatchConditionJsonDTO dispatchConditionJson = new ChatDispatchConditionJsonDTO();
        dispatchConditionJson.setMode(100);
        dispatchConditionJson.setOpenStrict(0);
        dispatchConditionJson.setOpenBlur(0);
        dispatchConditionJson.setStrictKeyWords(Lists.newArrayList());
        dispatchConditionJson.setBlurKeyWords(Lists.newArrayList());
        chatDispatchSettings.setDispatchConditionConf(JSON.toJSONString(dispatchConditionJson));
        result.setDispatchConditionConf(dispatchConditionJson);
        // 对话规则
        ChatDialogRuleJsonDTO dialogRuleJson = new ChatDialogRuleJsonDTO();
        dialogRuleJson.setOpenTimeout(0);
        dialogRuleJson.setReplyTimeout(1);
        dialogRuleJson.setSessionTimeout(1);
        dialogRuleJson.setEndTimeout(2);
        dialogRuleJson.setCleanTimeout(4);
        dialogRuleJson.setOpenEnd(1);
        chatDispatchSettings.setDialogRuleConf(JSON.toJSONString(dialogRuleJson));
        result.setDialogRuleConf(dialogRuleJson);
        // 自动回复
        ChatAutoReplyJsonDTO autoReplyJson = new ChatAutoReplyJsonDTO();
        autoReplyJson.setOpenQueueReply(0);
        autoReplyJson.setQueueReplyText("【系统消息】抱歉, 当前所有客服已达服务上限, 请稍等.");
        autoReplyJson.setQueueRepeatTime(3);
        autoReplyJson.setOpenEndReply(1);
        autoReplyJson.setEndReplyAutoText("【系统消息】您好,由于很久没有收到您的消息,系统自动结束了对话. 如果还要需要,欢迎随时联系我们.");
        autoReplyJson.setEndReplyManualText("【系统消息】您好,为了保证服务质量,我们已经结束了对话,期待再次为您服务.");
        autoReplyJson.setOpenLeave(1);
        ChatAutoReplyJsonDTO.LeaveItem leaveItem = new ChatAutoReplyJsonDTO.LeaveItem();
        leaveItem.setLeaveStart("00:00");
        leaveItem.setLeaveEnd("09:00");
        leaveItem.setLeaveReplyText("【系统消息】您好,由于很久没有收到您的消息,系统自动结束了对话. 如果还要需要,欢迎随时联系我们.");
        autoReplyJson.setLeaveItems(Lists.newArrayList(leaveItem));

        chatDispatchSettings.setAutoReplyConf(JSON.toJSONString(autoReplyJson));
        result.setAutoReplyConf(autoReplyJson);
        // 客服评价
        ChatEvaluateJsonDTO chatEvaluateJson = new ChatEvaluateJsonDTO();
        chatEvaluateJson.setOpenEvaluate(0);
        chatEvaluateJson.setRecvEvaluateReplyText("【系统评价】感谢您的评价，有问题欢迎随时再次咨询～");
        chatEvaluateJson.setEvaluateText("【系统评价】请您对我的本次服务作出评价，谢谢！\n" +
                "1代表好评；\n" +
                "2代表中评；\n" +
                "3代表差评；\n" +
                "请于24小时内评价，超时或回复其他任何内容将重新接入客服。");

        chatDispatchSettings.setEvaluateConf(JSON.toJSONString(chatEvaluateJson));
        result.setEvaluateConf(chatEvaluateJson);
        // 客服评价
        ChatOtherSettingJsonDTO otherSettingJson = new ChatOtherSettingJsonDTO();
        otherSettingJson.setOpenNewCustomerMsgFilter(0);
        chatDispatchSettings.setOtherSettingConf(JSON.toJSONString(otherSettingJson));
        result.setOtherSettingConf(otherSettingJson);

        chatDispatchSettings.setCreateTime((int) (System.currentTimeMillis() / 1000L));
        chatDispatchSettings.setUpdateTime((int) (System.currentTimeMillis() / 1000L));

        chatDispatchSettingsMapper.insertSelective(chatDispatchSettings);
        String confCacheKey = String.format(RedisCacheKeyEnum.MER_CHAT_DISPATCH_CONF.getKey(), merId);
        redisTemplate.opsForValue().set(confCacheKey, JSON.toJSONString(result));
        return get(merId);
    }

    public void update(LoginVO login, ChatDispatchSettingsDTO opt) {

        ChatDispatchSettings chatDispatchSettings = chatDispatchSettingsMapper.selectById(opt.getId());
        if (Objects.isNull(chatDispatchSettings)) {
            throw new BusinessException("分发配置不存在");
        }
        ChatDispatchSettings update = new ChatDispatchSettings();
        update.setId(chatDispatchSettings.getId());
        update.setOpenDispatch(opt.getOpenDispatch());

        if (Objects.nonNull(opt.getSessionAccessConf())) {
            update.setSessionAccessConf(JSON.toJSONString(opt.getSessionAccessConf()));
        }
        if (Objects.nonNull(opt.getAllocateRuleConf())) {
            update.setAllocateRuleConf(JSON.toJSONString(opt.getAllocateRuleConf()));
        }
        if (Objects.nonNull(opt.getDispatchConditionConf())) {
            update.setDispatchConditionConf(JSON.toJSONString(opt.getDispatchConditionConf()));
        }
        if (Objects.nonNull(opt.getDialogRuleConf())) {
            update.setDialogRuleConf(JSON.toJSONString(opt.getDialogRuleConf()));
        }
        if (Objects.nonNull(opt.getAutoReplyConf())) {
            update.setAutoReplyConf(JSON.toJSONString(opt.getAutoReplyConf()));
        }
        if (Objects.nonNull(opt.getEvaluateConf())) {
            update.setEvaluateConf(JSON.toJSONString(opt.getEvaluateConf()));
        }
        if (Objects.nonNull(opt.getOtherSettingConf())) {
            update.setOtherSettingConf(JSON.toJSONString(opt.getOtherSettingConf()));
        }

        update.setUpdateTime((int) (System.currentTimeMillis() / 1000L));
        chatDispatchSettingsMapper.updateByPrimaryKeySelective(update);

//        ChatDispatchSettingsVO dispatchSettings = this.get(chatDispatchSettings.getMerId());
//        String confCacheKey = String.format(RedisCacheKeyEnum.MER_CHAT_DISPATCH_CONF.getKey(), login.getMerId());
//        redisTemplate.opsForValue().set(confCacheKey, JSON.toJSONString(dispatchSettings));
    }
}
